﻿using Quartz;
using Quartz.Impl;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace QuartzJob
{
   public static class QuartzConfig {
        private static readonly string tiggerName = "UpdateTrigger";
        private static readonly string gropName = "UpadateTriggerGrop";
        private static readonly string jobName = "UpadateStateJob";
        //从工厂中获取一个调度器实例化
        private static Quartz.IScheduler scheduler = null;

        static QuartzConfig()
        {
            scheduler = StdSchedulerFactory.GetDefaultScheduler().Result;
            scheduler.Start();
        }
        /// <summary>
        /// 更新会议结束状态
        /// </summary>
        public static async void StartUpdateState()
    {
        //创建一个作业
        Quartz.IJobDetail job1 = Quartz.JobBuilder.Create<UpdateStateJob>()
         .WithIdentity(jobName, gropName)
         .UsingJobData("key", "value")// 传递参数 在Execute方法中获取（以什么类型值传入，取值就用相应的类型方法取值）
         .Build();

        // 创建触发器
        Quartz.ITrigger trigger1 = Quartz.TriggerBuilder.Create()
                                    .WithIdentity(tiggerName, gropName)
                                    .StartNow()                        //现在开始
                                    .WithSimpleSchedule(x => x         //触发时间，10秒一次。
                                        .WithIntervalInSeconds(60)
                                        .RepeatForever())              //不间断重复执行
                                    .Build();


        await scheduler.ScheduleJob(job1, trigger1);      //把作业，触发器加入调度器。
    }
        /// <summary>
        /// 定时获取wx手机号
        /// </summary>
    //     public static  void GetWXInfo()
    //{
    //    //创建一个作业
    //    Quartz.IJobDetail wxjob = Quartz.JobBuilder.Create<GetUserInfobyWechat>()
    //     .WithIdentity("WXMSG", "WXTriggerGroup")
    //     .UsingJobData("key", "value")// 传递参数 在Execute方法中获取（以什么类型值传入，取值就用相应的类型方法取值）
    //     .Build();

    //    // 创建触发器
    //    Quartz.ITrigger trigger1 = Quartz.TriggerBuilder.Create()
    //                                .WithIdentity("WXMSGTrigger", "WXTriggerGroup")
    //                                .StartNow()                        //现在开始
    //                                .WithSimpleSchedule(x => x         //触发时间，10个小时一次。
    //                                    .WithIntervalInHours(10)
    //                                    .RepeatForever())              //不间断重复执行
    //                                .Build();
    //     scheduler.ScheduleJob(wxjob, trigger1);      //把作业，触发器加入调度器。

    //}
        public static async void AddJobsForHours<T>(String jobName,int Hours,string value) where T:IJob {
            //创建一个作业
            Quartz.IJobDetail wxjob = Quartz.JobBuilder.Create<T>()
             .WithIdentity(jobName, jobName+"Group")
             .UsingJobData(jobName+"key", value)// 传递参数 在Execute方法中获取（以什么类型值传入，取值就用相应的类型方法取值）
             .Build();

            // 创建触发器
            Quartz.ITrigger trigger1 = Quartz.TriggerBuilder.Create()
                                        .WithIdentity(jobName+"Trigger", jobName+"Group")
                                        .StartNow()                        //现在开始
                                        .WithSimpleSchedule(x => x         //触发时间，10个小时一次。
                                            .WithIntervalInHours(Hours)
                                            .RepeatForever())              //不间断重复执行
                                        .Build();
            await scheduler.ScheduleJob(wxjob, trigger1);      //把作业，触发器加入调度器。
        }
        public static async void AddJobsForMinute<T>(String jobName, int minutes, string value) where T : IJob
        {
            //创建一个作业
            Quartz.IJobDetail wxjob = Quartz.JobBuilder.Create<T>()
             .WithIdentity(jobName, jobName + "Group")
             .UsingJobData(jobName + "key", value)// 传递参数 在Execute方法中获取（以什么类型值传入，取值就用相应的类型方法取值）
             .Build();

            // 创建触发器
            Quartz.ITrigger trigger1 = Quartz.TriggerBuilder.Create()
                                        .WithIdentity(jobName + "Trigger", jobName + "Group")
                                        .StartNow()                        //现在开始
                                        .WithSimpleSchedule(x => x       
                                            .WithIntervalInMinutes(minutes)
                                            .RepeatForever())              //不间断重复执行
                                        .Build();
            await scheduler.ScheduleJob(wxjob, trigger1);      //把作业，触发器加入调度器。
        }
        public static async void AddJobsForSeconds<T>(String jobName, int Seconds, string value) where T : IJob
        {
            //创建一个作业
            Quartz.IJobDetail wxjob = Quartz.JobBuilder.Create<T>()
             .WithIdentity(jobName, jobName + "Group")
             .UsingJobData(jobName + "key", value)// 传递参数 在Execute方法中获取（以什么类型值传入，取值就用相应的类型方法取值）
             .Build();

            // 创建触发器
            Quartz.ITrigger trigger1 = Quartz.TriggerBuilder.Create()
                                        .WithIdentity(jobName + "Trigger", jobName + "Group")
                                        .StartNow()                        //现在开始
                                        .WithSimpleSchedule(x => x         //触发时间，10个小时一次。
                                            .WithIntervalInSeconds(Seconds)
                                            .RepeatForever())              //不间断重复执行
                                        .Build();
            await scheduler.ScheduleJob(wxjob, trigger1);      //把作业，触发器加入调度器。
        }
        
    }
}

